
#include <assert.h>
#include <time.h>
#include "sdlJeu.h"

const int TAILLE_SPRITE=32;


SDL_Surface *SDL_load_image(const char* filename )
{
	/* Temporary storage for the image that's loaded */
	SDL_Surface* loadedImage = NULL;

	/* The optimized image that will be used */
	SDL_Surface* optimizedImage = NULL;

	/* Load the image */
	loadedImage = SDL_LoadBMP( filename );

	/* If nothing went wrong in loading the image */
	if ( loadedImage != NULL )
	{
		/* Create an optimized image */
		optimizedImage = SDL_DisplayFormat( loadedImage );

		/* Free the old image */
		SDL_FreeSurface( loadedImage );
	}

	/* Return the optimized image */
	return optimizedImage;
}


void SDL_apply_surface( SDL_Surface* source, SDL_Surface* destination, int x, int y )
{
	/* Make a temporary rectangle to hold the offsets */
	SDL_Rect offset;

	/* Give the offsets to the rectangle */
	offset.x = x;
	offset.y = y;

	/* Blit the surface */
	SDL_BlitSurface( source, NULL, destination, &offset );
}


void sdljeuInit(sdlJeu *pSdlJeu)
{
	Jeu *pJeu;
	int dimx, dimy;

	pJeu = &(pSdlJeu->jeu);
	initialiser_Jeu(pJeu);

	assert(   SDL_Init( SDL_INIT_EVERYTHING )!= -1 );

	dimx = getDimx( jeuGetConstTerrain(pJeu) );
	dimy = getDimy( jeuGetConstTerrain(pJeu) );
	dimx = dimx * TAILLE_SPRITE;
	dimy = dimy * TAILLE_SPRITE;
	pSdlJeu->surface_ecran = SDL_SetVideoMode(   dimx, dimy, 32, SDL_SWSURFACE );
	assert( pSdlJeu->surface_ecran!=NULL);
	SDL_WM_SetCaption( "Tower Defense v0.1", NULL );

	pSdlJeu->surface_creature = SDL_load_image("data/creature.bmp");
	if (pSdlJeu->surface_creature==NULL)
		pSdlJeu->surface_creature = SDL_load_image("../data/creature.bmp");
	/*assert( pSdlJeu->surface_creature!=NULL);*/

	pSdlJeu->surface_terrain = SDL_load_image("data/terrain.bmp");
	if (pSdlJeu->surface_terrain==NULL)
		pSdlJeu->surface_terrain = SDL_load_image("../data/terrain.bmp");
	/*assert( pSdlJeu->surface_chemin!=NULL);*/
	
	pSdlJeu->surface_chemin = SDL_load_image("data/chemin.bmp");
	if (pSdlJeu->surface_chemin==NULL)
		pSdlJeu->surface_chemin = SDL_load_image("../data/chemin.bmp");
	/*assert( pSdlJeu->surface_tour!=NULL);*/

	pSdlJeu->surface_tour = SDL_load_image("data/tour.bmp");
	if (pSdlJeu->surface_tour==NULL)
		pSdlJeu->surface_tour = SDL_load_image("../data/tour.bmp");
	/*assert( pSdlJeu->surface_tour!=NULL);*/
}

void sdljeuLibere( sdlJeu *pSdlJeu)
{
	SDL_FreeSurface( pSdlJeu->surface_creature );
	SDL_FreeSurface( pSdlJeu->surface_terrain );
	SDL_FreeSurface( pSdlJeu->surface_chemin );
	SDL_FreeSurface( pSdlJeu->surface_base );
	SDL_FreeSurface( pSdlJeu->surface_tour );

	liberer_Jeu(&(pSdlJeu->jeu));

	SDL_Quit();
}

void sdljeuAff(sdlJeu *pSdlJeu)
{
	int x,y;

    const Jeu *pJeu = &(pSdlJeu->jeu);
	const Terrain *pTer = jeuGetConstTerrain(pJeu);
	/*const Pacman *pPac = jeuGetConstPacman(pJeu);*/

	/* Remplir l'écran de blanc */
	SDL_FillRect( pSdlJeu->surface_ecran, &pSdlJeu->surface_ecran->clip_rect, SDL_MapRGB( pSdlJeu->surface_ecran->format, 0xFF, 0xFF, 0xFF ) );

	for (x=0;x<getDimx(pTer);++x)
		for (y=0;y<getDimy(pTer);++y)
			if (terGetXY(pTer,x,y)=='#')
				SDL_apply_surface(  pSdlJeu->surface_terrain, pSdlJeu->surface_ecran, x*TAILLE_SPRITE, y*TAILLE_SPRITE);
				else if(terGetXY(pTer,x,y)==':')
					SDL_apply_surface(  pSdlJeu->surface_chemin, pSdlJeu->surface_ecran, x*TAILLE_SPRITE, y*TAILLE_SPRITE);
					else if(terGetXY(pTer,x,y)=='%')
						SDL_apply_surface(  pSdlJeu->surface_tour, pSdlJeu->surface_ecran, x*TAILLE_SPRITE, y*TAILLE_SPRITE);
						else 
							SDL_apply_surface(  pSdlJeu->surface_base, pSdlJeu->surface_ecran, x*TAILLE_SPRITE, y*TAILLE_SPRITE);
				
				

   /* for (x=0;x<creagetConstPositionX(pJeu->tabcrea[0]);++x)
		for (y=0;y<creagetConstPositionY(pJeu->tabcrea[0]);++y)
			if (terGetXY(pTer,x,y)==':')
				SDL_apply_surface(  pSdlJeu->surface_creature, pSdlJeu->surface_ecran, (pJeu->tabcrea[i_crea].positionX)*TAILLE_SPRITE, (pJeu->tabcrea[i_crea].positionY)*TAILLE_SPRITE);*/

	/* Copier le sprite de Pacman sur l'écran */
	/*SDL_apply_surface(  pSdlJeu->surface_tour, pSdlJeu->surface_ecran, *TAILLE_SPRITE,  *TAILLE_SPRITE );*/
}

void sdljeuBoucle(sdlJeu *pSdlJeu)
{
	SDL_Event event;
	int continue_boucle = 1;

    /* Horloges (en secondes) */
    float horloge_courante, horloge_precedente;

    /* Intervalle de temps (en secondes) entre deux évolutions du jeu */
    /* Changer la valeur pour ralentir ou accélérer le déplacement des fantomes */
    float intervalle_horloge = 0.1f;

    int rafraichissement;

	sdljeuAff(pSdlJeu);
	assert( SDL_Flip( pSdlJeu->surface_ecran )!=-1 );

    /* Récupère l'horloge actuelle et la convertit en secondes */
    /* clock() retourne le nombre de tops horloge depuis le lancement du programme */
    horloge_precedente = (float)clock()/(float)CLOCKS_PER_SEC;

	/* Tant que ce n'est pas la fin ... */
	while ( continue_boucle == 1 )
	{
	    rafraichissement = 0;

	     /* Récupère l'horloge actuelle et la convertit en secondes */
        horloge_courante = (float)clock()/(float)CLOCKS_PER_SEC;

        /* Si suffisamment de temps s'est écoulé depuis la dernière prise d'horloge */
        if (horloge_courante-horloge_precedente>=intervalle_horloge)
        {
                jeuEvolue(&(pSdlJeu->jeu));
                rafraichissement = 1;
                horloge_precedente = horloge_courante;
        }

		/* tant qu'il y a des evenements à traiter : cette boucle n'est pas bloquante */
		while ( SDL_PollEvent( &event ) )
		{
			/* Si l'utilisateur a cliqué sur la croix de fermeture */
			if ( event.type == SDL_QUIT )
			{
				continue_boucle = 0;
			}

			/* Si l'utilisateur a appuyé sur une touche */
			/*if ( event.type == SDL_KEYDOWN )
			{
				switch ( event.key.keysym.sym )
				{
				case SDLK_UP:
					
					break;
				case SDLK_DOWN:
					
					break;
				case SDLK_LEFT:
					
					break;
				case SDLK_RIGHT:
					
					break;
				default: break;
				}*/
		}

	}

        if (rafraichissement==1)
        {
            /* on affiche le jeu sur le buffer caché */
            sdljeuAff(pSdlJeu);

            /* on permute les deux buffers (cette fonction ne doit se faire qu'une seule fois dans a boucle) */
            SDL_Flip( pSdlJeu->surface_ecran );
        }
}
